home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / ERROR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-04  |  6.1 KB  |  323 lines
  1. #include <ctype.h>
  2.  
  3. #include "global.h"
  4. #include "edit.h"
  5. #include "icon.h"
  6. #include "mintlib.h"
  7. #include "rsc.h"
  8. #include "set.h"
  9. #include "text.h"
  10. #include "error.h"
  11.  
  12. /*
  13.  * Exportierte Variablen:
  14. */
  15. UBYTE    error[3][40];
  16.  
  17. /*
  18.  * lokales
  19. */
  20. typedef enum {nil, read_text, read_name, read_zeile, read_spalte, read_fehler} TOKEN;
  21.  
  22. #define MAX_TOKEN        10                /* Anzahl der Token */
  23. #define MAX_ERRLEN    120            /* Länge der Fehlerzeile */
  24.  
  25. typedef struct
  26. {
  27.     TOKEN    token;
  28.     UBYTE    text[10];
  29. } TOKENELEM, *TEP;
  30.  
  31. LOCAL TOKENELEM    token_list[MAX_TOKEN];
  32. LOCAL WORD            token_anzahl;
  33. LOCAL    PATH            error_name;                    /* Dateiname des Errorfiles */
  34.  
  35. /* das Ergebnis */
  36. LOCAL PATH    dateiname;
  37. LOCAL UBYTE    fehlertext[MAX_ERRLEN];
  38. LOCAL LONG    fehlerzeile;
  39. LOCAL WORD    fehlerspalte;
  40.  
  41. LOCAL VOID init_parser(UBYTE *muster)
  42. {
  43.     UBYTE    tmp[2] = " ";
  44.     WORD    i;
  45.     TOKEN last_token;
  46.  
  47.     strcpy(dateiname, "");
  48.     fehlerzeile = -1;
  49.     fehlerspalte = -1;
  50.     strcpy(fehlertext, "");
  51.  
  52.     token_anzahl = 0;
  53.     last_token = nil;
  54.     for (i = 0; i < MAX_TOKEN; i++)
  55.     {
  56.         token_list[i].token = nil;
  57.         strcpy(token_list[i].text, "");
  58.     }
  59.  
  60.     for (i = 0; i < (short)strlen(muster); i++)
  61.     {
  62.         switch (muster[i])
  63.         {
  64.             case '%' :
  65.                 i++;
  66.                 if (last_token == read_text)
  67.                     token_anzahl++;
  68.                 switch (muster[i])
  69.                 {
  70.                     case 'f' :
  71.                         token_list[token_anzahl].token = read_name;
  72.                         last_token = read_name;
  73.                         break;
  74.                     case 'z' :
  75.                         token_list[token_anzahl].token = read_zeile;
  76.                         last_token = read_zeile;
  77.                         break;
  78.                     case 's' :
  79.                         token_list[token_anzahl].token = read_spalte;
  80.                         last_token = read_spalte;
  81.                         break;
  82.                     case 't' :
  83.                         token_list[token_anzahl].token = read_fehler;
  84.                         last_token = read_fehler;
  85.                         break;
  86.                 }
  87.                 break;
  88.             default:
  89.                 if (last_token > read_text)
  90.                     token_anzahl++;
  91.                 token_list[token_anzahl].token = read_text;
  92.                 tmp[0] = muster[i];
  93.                 strcat(token_list[token_anzahl].text, tmp);
  94.                 last_token = read_text;
  95.                 break;
  96.         }
  97.     }
  98. }
  99.  
  100.  
  101. LOCAL BOOLEAN    readin_text(UBYTE *zeile, WORD *pos, UBYTE *text)
  102. {
  103.     WORD    len = (short)strlen(text),
  104.             i;
  105.     UBYTE    tmp[10];
  106.  
  107.     i = *pos;
  108.     while ( (i < (short)strlen(zeile)) && (i < (len + *pos)))
  109.     {
  110.         tmp[i - *pos] = zeile[i];
  111.         i++;
  112.     }
  113.     if (i > *pos)
  114.     {
  115.         tmp[i - *pos] = EOS;
  116.         *pos = i;
  117.         return (strcmp(tmp, text) == 0);
  118.     }
  119.     else
  120.         return FALSE;
  121. }
  122.  
  123. LOCAL BOOLEAN    readin_name(UBYTE *zeile, WORD *pos)
  124. {
  125.     SET    valid_char;
  126.     PATH    tmp;
  127.     WORD    i;
  128.  
  129.     strcpy(tmp,"-+._~\\/A-Za-z0-9");                /* Zulässige Zeichen für Dateinamen */
  130.     str2set(tmp, valid_char);
  131.     i = *pos;
  132.     while (     (i < (short)strlen(zeile)) &&     /* Sonderbehandlung für ':', nur im Pfad erlaubt! */
  133.                 ((setin(valid_char, zeile[i])) ||
  134.                  (zeile[i] == ':' && (zeile[i+1] == '\\') || zeile[i+1] == '/')))
  135.     {
  136.         tmp[i - *pos] = zeile[i];
  137.         i++;
  138.     }
  139.     if (i > *pos)
  140.     {
  141.         tmp[i - *pos] = EOS;
  142.         *pos = i;
  143.  
  144.         if (strchr(tmp, '/') != NULL)                /* UNIX-Pfad -> nach TOS wandeln */
  145.         {
  146.             unx2dos(tmp);
  147.             strcpy(dateiname, tmp);
  148.         }
  149.         else if (tmp[1] != ':')                        /* Kein Laufwerk -> Name ohne Pfad! */
  150.         {
  151.  
  152.             file_splitt(error_name, dateiname, NULL);
  153.             strcat(dateiname, tmp);
  154.         }
  155.         else
  156.             strcpy(dateiname, tmp);
  157.         if (!caseSens(dateiname, NULL))
  158.             str_upper(dateiname);
  159.         return (file_exist(dateiname));
  160.     }
  161.     else
  162.         return FALSE;
  163. }
  164.  
  165. LOCAL BOOLEAN    readin_zeile(UBYTE *zeile, WORD *pos)
  166. {
  167.     WORD    i;
  168.     UBYTE    tmp[10];
  169.  
  170.     i= *pos;
  171.     while ( (i < (short)strlen(zeile)) && (isdigit(zeile[i])) )
  172.     {
  173.         tmp[i - *pos] = zeile[i];
  174.         i++;
  175.     }
  176.     if (i > *pos)
  177.     {
  178.         tmp[i - *pos] = EOS;
  179.         fehlerzeile = atol(tmp);
  180.         *pos = i;
  181.         return TRUE;
  182.     }
  183.     else
  184.         return FALSE;
  185. }
  186.  
  187. LOCAL BOOLEAN    readin_spalte(UBYTE *zeile, WORD *pos)
  188. {
  189.     WORD    i;
  190.     UBYTE    tmp[10];
  191.  
  192.     i= *pos;
  193.     while ( (i < (short)strlen(zeile)) && (isdigit(zeile[i])) )
  194.     {
  195.         tmp[i - *pos] = zeile[i];
  196.         i++;
  197.     }
  198.     if (i > *pos)
  199.     {
  200.         tmp[i - *pos] = EOS;
  201.         fehlerspalte = atoi(tmp);
  202.         *pos = i;
  203.         return TRUE;
  204.     }
  205.     else
  206.         return FALSE;
  207. }
  208.  
  209. LOCAL BOOLEAN    readin_fehler(UBYTE *zeile, WORD *pos)
  210. {
  211.     WORD    i, j;
  212.     UBYTE    tmp[MAX_ERRLEN];
  213.  
  214.     i = *pos;
  215.     j = 0;
  216.     while ( (i < (short)strlen(zeile)) && (j < sizeof(tmp)) )
  217.     {
  218.         tmp[i - *pos] = zeile[i];
  219.         i++;
  220.         j++;
  221.     }
  222.     if (i > *pos)
  223.     {
  224.         tmp[i - *pos] = EOS;
  225.         *pos = i;
  226.         strcpy(fehlertext, tmp);
  227.         return TRUE;
  228.     }
  229.     else
  230.         return FALSE;
  231. }
  232.  
  233. LOCAL BOOLEAN    parse_line(UBYTE *zeile)
  234. {
  235.     WORD        i, z_pos = 0;
  236.     BOOLEAN    ok = FALSE;
  237.  
  238.     for (i = 0; i <= token_anzahl; i++)
  239.     {
  240.         switch (token_list[i].token)
  241.         {
  242.             case read_text :
  243.                 ok = readin_text(zeile, &z_pos, token_list[i].text);
  244.                 break;
  245.             case read_name :
  246.                 ok = readin_name(zeile, &z_pos);
  247.                 break;
  248.             case read_zeile :
  249.                 ok = readin_zeile(zeile, &z_pos);
  250.                 break;
  251.             case read_spalte :
  252.                 ok = readin_spalte(zeile, &z_pos);
  253.                 break;
  254.             case read_fehler :
  255.                 ok = readin_fehler(zeile, &z_pos);
  256.                 break;
  257.         }
  258.         if (!ok)
  259.             break;
  260.     }
  261.     return ok;;
  262. }
  263.  
  264.  
  265. GLOBAL VOID    handle_error(TEXTP t_ptr)
  266. {
  267.     WORD    icon, i;
  268.     UBYTE    str[256];
  269.  
  270.     for (i = 0; i < 3; i++)
  271.     {
  272.         init_parser(error[i]);
  273.         strcpy(error_name, t_ptr->filename);
  274.         if (parse_line(TEXT(t_ptr->cursor_line)))
  275.         {
  276.             if ((icon = still_loaded(dateiname)) >=0 )
  277.                 do_icon(icon, DO_OPEN);                            /* Nur Fenster öffnen */
  278.             else
  279.                 icon = load_edit(dateiname,TRUE,-1,-1,NULL);    /* Laden als Text und öffnen */
  280.             if (icon > 0)
  281.             {
  282.                 if (fehlerspalte > 0)
  283.                     desire_x = fehlerspalte - 1;    /* wir fange bei 0 an! */
  284.                 else
  285.                     desire_x = 0;
  286.                 if (fehlerzeile > 0)
  287.                     desire_y = fehlerzeile - 1;
  288.                 else
  289.                     desire_y = 0;
  290.  
  291.                 if (strlen(fehlertext) > 0)
  292.                 {
  293.                     strcpy(str, STRING(ERRORSTR));
  294.                     strcat(str, fehlertext);
  295.                     set_info(get_text(icon), str);
  296.                 }
  297.                 Icon_edit(icon, DO_GOTO);
  298.                 return;
  299.             }
  300.         }
  301.     }
  302.     mybeep();
  303. }
  304.  
  305. /*
  306.  * Die Dialogbox für die Fehlerzeile
  307.  */
  308. GLOBAL VOID    fehler_box(VOID)
  309. {
  310.     WORD    antw, i;
  311.  
  312.     for (i = 0; i < 3; i++)
  313.         objc_setstring(fehler, FEHLTEXT1 + i, error[i]);
  314.     Arrow_mouse();
  315.     antw = HndlDial(fehler, 0, FALSE, NULL, NULL);
  316.     Last_mouse();
  317.     if (antw == FEHLOK)
  318.     {
  319.         for (i = 0; i < 3; i++)
  320.             objc_getstring(fehler, FEHLTEXT1 + i, error[i]);
  321.     }
  322. }
  323.